//public class Array{
//    public static void main(String[] args){
//        System.out.println("Array");
//    }
//
//    /**
//     * 创建数组
//     */
//    void creatArray(){
//        // 数组是一个固定长度的，包含了相同类型数据的容器
//
//        /**
//         * 声明数组 ： int[] a  即声明了一个数组变量。
//         *      []表示该变量是一个数组
//         *      int 表示数组里的每一个元素都是一个整数
//         *      a 是变量名
//         *      但是，仅仅是这一句声明，不会创建数组
//         * 有时候也会写成int a[]; 没有任何区别，就是你看哪种顺眼的问题
//         *
//         *
//         * 创建数组 ： 要指明数组的长度。
//         *      引用概念：
//         *          如果变量代表一个数组，比如a,我们把a叫做引用
//         *          与基本类型不同
//         *              int c = 5; 这叫给c赋值为5
//         *          声明一个引用 int[] a;
//         *              a = new int[5];
//         *              让a这个引用，指向数组
//         */
//        //声明一个引用
//        int[] a1;
//        //创建一个长度是5的数组，并且使用引用a指向该数组
//        a1 = new int[5];
//        int[] b1 = new int[5]; //声明的同时，指向一个数组
//
//
//        /**
//         * 访问数组
//         *      数组下标基0
//         *      下标0，代表数组里的第一个数
//         */
//        int[] a2;
//        a2 = new int[5];
//        a2[0]= 1;  //下标0，代表数组里的第一个数
//        a2[1]= 2;
//        a2[2]= 3;
//        a2[3]= 4;
//        a2[4]= 5;
//
//
//        /**
//         * 数组长度
//         *      .length属性用于访问一个数组的长度
//         *      数组访问下标范围是0到长度-1
//         *      一旦超过这个范围,就会产生数组下标越界异常
//         */
//        int[] a3;
//        a3 = new int[5];
//        System.out.println(a3.length); //打印数组的长度
//        a3[4]=100; //下标4，实质上是“第5个”，即最后一个
//        a3[5]=101; //下标5，实质上是“第6个”，超出范围 ,产生数组下标越界异常
//
//
//        /**
//         * 数组最小值
//         *      首先创建一个长度是5的数组
//         *      然后给数组的每一位赋予随机整数
//         *      通过for循环，遍历数组，找出最小的一个值出来
//         */
//        int[] a = new int[5];
//        a[0] = (int) (Math.random() * 100); // 0-100的 随机整数
//        a[1] = (int) (Math.random() * 100);
//        a[2] = (int) (Math.random() * 100);
//        a[3] = (int) (Math.random() * 100);
//        a[4] = (int) (Math.random() * 100);
//        System.out.println("数组中的各个随机数是:");
//        for (int i = 0; i < a.length; i++)
//            System.out.println(a[i]);
//        System.out.println("本练习的目的是，找出最小的一个值: ");
//    }
//
//    /**
//     * 初始化数组
//     */
//    void initArray(){
//        /**
//         * 分配空间与赋值分步进行
//         */
//        int[] a1 = new int[5]; //分配了长度是5的数组，但是没有赋值
//        //没有赋值，那么就会使用默认值
//        //作为int类型的数组，默认值是0
//        System.out.println(a1[0]);
//        //进行赋值
//        a1[0] = 100;
//        a1[1] = 101;
//        a1[2] = 103;
//        a1[3] = 120;
//        a1[4] = 140;
//
//
//        /**
//         * 分配空间，同时赋值
//         */
//        //写法一： 分配空间同时赋值
//        int[] a = new int[]{100,102,444,836,3236};
//
//        //写法二： 省略了new int[],效果一样
//        int[] b = {100,102,444,836,3236};
//
//        //写法三：同时分配空间，和指定内容
//        //在这个例子里，长度是3，内容是5个，产生矛盾了
//        //所以如果指定了数组的内容，就不能同时设置数组的长度
//        int[] c = new int[3]{100,102,444,836,3236};
//    }
//
//    /**
//     * 排序
//     */
//    void sort(){
//        int a [] = new int[]{18,62,68,82,65,9};
//
//        /**
//         * 选择法排序
//         *      把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来
//         *      比较完后，第一位就是最小的
//         *      然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来
//         *      比较完后，第二位就是第二小的
//         *      以此类推
//         */
//        for (int j = 0; j < a.length-1; j++) {
//            for (int i = j+1; i < a.length; i++) {
//                if(a[i]<a[j]){
//                    int temp = a[j];
//                    a[j] = a[i];
//                    a[i] = temp;
//                }
//            }
//        }
//
//
//        /**
//         * 冒泡法排序
//         *      第一步：从第一位开始，把相邻两位进行比较
//         *      如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的
//         *      第二步： 再来一次，只不过不用比较最后一位
//         *      以此类推
//         */
//        for (int j = 0; j < a.length; j++) {
//            for (int i = 0; i < a.length-j-1; i++) {
//                if(a[i]>a[i+1]){
//                    int temp = a[i];
//                    a[i] = a[i+1];
//                    a[i+1] = temp;
//                }
//            }
//        }
//    }
//
//    /**
//     * 增强型 for循环
//     */
//    void enhancedFor(){
//        // 注：增强型for循环只能用来取值，却不能用来修改数组里的值
//
//        int values [] = new int[]{18,62,68,82,65,9};
//
//        //常规遍历
//        for (int i = 0; i < values.length; i++) {
//            int each = values[i];
//            System.out.println(each);
//        }
//
//        //增强型for循环遍历
//        for (int each : values) {
//            System.out.println(each);
//        }
//    }
//
//    /**
//     * 复制数组
//     */
//    void copyArray(){
//        /**
//         * 把一个数组的值，复制到另一个数组中
//         *      System.arraycopy(src, srcPos, dest, destPos, length)
//         *          src: 源数组
//         *          srcPos: 从源数组复制数据的起始位置
//         *          dest: 目标数组
//         *          destPos: 复制到目标数组的起始位置
//         *          length: 复制的长度
//         */
//        int a [] = new int[]{18,62,68,82,65,9};
//        int b[] = new int[3];//分配了长度是3的空间，但是没有赋值
//
//        //通过数组赋值把，a数组的前3位赋值到b数组
//
//        //方法一： for循环
//        for (int i = 0; i < b.length; i++) {
//            b[i] = a[i];
//        }
//
//        //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
//        System.arraycopy(a, 0, b, 0, 3);
//    }
//
//    /**
//     * 二维数组
//     */
//    void twoDimensionalArray(){
//        /**
//         * 初始化二维数组
//         */
//        //初始化二维数组，
//        int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
//        a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
//
//        //只分配了二维数组
//        int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
//        b[0] = new int[3]; //必须事先分配长度，才可以访问
//        b[0][2] = 5;
//
//        //指定内容的同时，分配空间
//        int[][] c = new int[][]{
//            {1,2,4},
//            {4,5},
//            {6,7,8,9}
//        };
//    }
//
//    /**
//     * Arrays
//     */
//    void Arrays(){
//        // Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。
//
//        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
//
//        /**
//         * 数组复制
//         *      与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
//         *      不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
//         *      除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。
//         */
//        // copyOfRange(int[] original, int from, int to)
//        // 第一个参数表示源数组
//        // 第二个参数表示开始位置(取得到)
//        // 第三个参数表示结束位置(取不到)
//        int[] b = Arrays.copyOfRange(a, 0, 3);
//        for (int i = 0; i < b.length; i++) {
//            System.out.print(b[i] + " ");
//        }
//
//
//        /**
//         * 转换为字符串
//         *      如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印
//         *      但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容
//         */
//        String content = Arrays.toString(a);
//        System.out.println(content);
//
//
//        /**
//         * 排序
//         *      Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。
//         */
//        System.out.println("排序之前 :");
//        System.out.println(Arrays.toString(a));
//        Arrays.sort(a);
//        System.out.println("排序之后:");
//        System.out.println(Arrays.toString(a));
//
//
//        /**
//         * 搜索
//         *      查询元素出现的位置
//         *      需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
//         *      如果数组中有多个相同的元素，查找结果是不确定的
//         */
//        Arrays.sort(a);
//        System.out.println(Arrays.toString(a));
//        //使用binarySearch之前，必须先使用sort进行排序
//        System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));
//
//
//        /**
//         * 判断是否相同
//         */
//        int aa[] = new int[] { 18, 62, 68, 82, 65, 9 };
//        int bb[] = new int[] { 18, 62, 68, 82, 65, 8 };
//        // 比较两个数组的内容是否一样
//        System.out.println(Arrays.equals(aa, bb)); // false
//
//
//        /**
//         * 填充
//         */
//        int cc[] = new int[10];
//        // 使用同一个值，填充整个数组
//        Arrays.fill(cc, 5);
//        System.out.println(Arrays.toString(cc));
//    }
//}